// 立即执行的测试代码
console.log('=== grading.js 文件已加载 ===');
console.log('当前时间:', new Date().toLocaleString());

// 全局变量
let currentFile = '';
let selectedGrade = 'B';  // 设置默认评分为 B
let gradeMode = 'letter';  // 评分方式：'letter' 或 'text'
var currentFilePath = null;
let pendingGrade = null;  // 待确认的评分

// 获取 CSRF Token
window.getCSRFToken = function() {
  const name = 'csrftoken';
  let cookieValue = null;
  if (document.cookie && document.cookie !== '') {
    const cookies = document.cookie.split(';');
    for (let i = 0; i < cookies.length; i++) {
      const cookie = cookies[i].trim();
      if (cookie.substring(0, name.length + 1) === (name + '=')) {
        cookieValue = decodeURIComponent(cookie.substring(name.length + 1));
        break;
      }
    }
  }
  return cookieValue;
}

// 显示错误信息
function showError(message) {
  const alertHtml = `
        <div class="alert alert-danger alert-dismissible fade show" role="alert">
            ${message}
            <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
        </div>
    `;
  $('#file-content').html(alertHtml);
}

// 显示加载指示器
function showLoading() {
  $('#loading').show();
}

// 隐藏加载指示器
function hideLoading() {
  $('#loading').hide();
}

// 设置评分按钮状态
window.setGradeButtonState = function(grade) {
  console.log('=== 设置评分按钮状态开始 ===');
  console.log('目标评分:', grade);
  console.log('评分按钮总数:', $('.grade-button').length);

  // 验证评分参数
  if (!grade) {
    console.error('评分参数为空');
    return;
  }

  // 移除所有评分按钮的active状态
  $('.grade-button').removeClass('active');
  console.log('已移除所有评分按钮的active状态');

  // 查找目标按钮
  const targetButton = $(`.grade-button[data-grade="${grade}"]`);
  console.log('目标评分按钮:', targetButton.length, targetButton.text());

  if (targetButton.length === 0) {
    console.error('未找到目标评分按钮:', grade);
    console.log('可用的评分按钮:');
    $('.grade-button').each(function() {
      console.log('-', $(this).data('grade'), ':', $(this).text());
    });
    return;
  }

  // 设置目标按钮为active状态
  targetButton.addClass('active');
  console.log('已设置目标按钮为active状态');

  // 更新全局变量
  selectedGrade = grade;

  console.log('=== 评分按钮状态设置完成 ===');
  console.log('当前评分:', selectedGrade);
}

// 切换评分方式
window.switchGradeMode = function(mode) {
  console.log('=== 切换评分方式开始 ===');
  console.log('目标模式:', mode);
  console.log('当前评分方式按钮数量:', $('.grade-mode-btn').length);
  console.log('字母评分按钮组:', $('#letter-grade-buttons').length);
  console.log('文字评分按钮组:', $('#text-grade-buttons').length);

  // 验证模式参数
  if (mode !== 'letter' && mode !== 'text') {
    console.error('无效的评分模式:', mode);
    return;
  }

  gradeMode = mode;

  // 更新按钮状态
  $('.grade-mode-btn').removeClass('active');
  const targetButton = $(`.grade-mode-btn[data-mode="${mode}"]`);
  console.log('目标按钮:', targetButton.length, targetButton.text());

  if (targetButton.length === 0) {
    console.error('未找到目标按钮:', mode);
    return;
  }

  targetButton.addClass('active');

  // 显示/隐藏对应的评分按钮组
  if (mode === 'letter') {
    console.log('切换到字母评分方式');

    // 隐藏文字评分按钮组
    $('#text-grade-buttons').hide();
    console.log('文字评分按钮组已隐藏');

    // 显示字母评分按钮组
    $('#letter-grade-buttons').show();
    console.log('字母评分按钮组已显示');

    // 验证显示状态
    console.log('字母评分按钮组显示状态:', $('#letter-grade-buttons').is(':visible'));
    console.log('文字评分按钮组显示状态:', $('#text-grade-buttons').is(':visible'));

    // 设置默认评分
    if (!selectedGrade || !['A', 'B', 'C', 'D', 'E'].includes(selectedGrade)) {
      console.log('设置默认字母评分: B');
      selectedGrade = 'B';
    } else {
      console.log('保持当前字母评分:', selectedGrade);
    }

    // 设置按钮状态
    setGradeButtonState(selectedGrade);

  } else if (mode === 'text') {
    console.log('切换到文字评分方式');

    // 隐藏字母评分按钮组
    $('#letter-grade-buttons').hide();
    console.log('字母评分按钮组已隐藏');

    // 显示文字评分按钮组
    $('#text-grade-buttons').show();
    console.log('文字评分按钮组已显示');

    // 验证显示状态
    console.log('字母评分按钮组显示状态:', $('#letter-grade-buttons').is(':visible'));
    console.log('文字评分按钮组显示状态:', $('#text-grade-buttons').is(':visible'));

    // 设置默认评分
    if (!selectedGrade || !['优秀', '良好', '中等', '及格', '不及格'].includes(selectedGrade)) {
      console.log('设置默认文字评分: 良好');
      selectedGrade = '良好';
    } else {
      console.log('保持当前文字评分:', selectedGrade);
    }

    // 设置按钮状态
    setGradeButtonState(selectedGrade);
  }

  console.log('=== 评分方式切换完成 ===');
  console.log('当前评分:', selectedGrade);
  console.log('评分方式:', gradeMode);

  // 验证显示一致性
  validateGradeModeDisplay();
}

// 检查教师评价按钮状态
function checkTeacherCommentButton() {
  const button = $('#teacher-comment-btn');
  console.log('Teacher comment button check:');
  console.log('- Element exists:', button.length > 0);
  console.log('- Disabled state:', button.prop('disabled'));
  console.log('- Current file path:', currentFilePath);
  console.log('- Button text:', button.text());
}

// 启用教师评价按钮
function enableTeacherCommentButton() {
  console.log('Enabling teacher comment button');
  $('#teacher-comment-btn').prop('disabled', false);
  checkTeacherCommentButton();
}

// 禁用教师评价按钮
function disableTeacherCommentButton() {
  console.log('Disabling teacher comment button');
  $('#teacher-comment-btn').prop('disabled', true);
  checkTeacherCommentButton();
}

// 启用AI评分按钮
function enableAiScoreButton() {
  console.log('=== 启用AI评分按钮 ===');
  console.log('按钮元素:', $('#ai-score-btn').length);
  console.log('启用前状态:', $('#ai-score-btn').prop('disabled'));
  $('#ai-score-btn').prop('disabled', false);
  console.log('启用后状态:', $('#ai-score-btn').prop('disabled'));
  console.log('按钮文本:', $('#ai-score-btn').text());
}

// 禁用AI评分按钮
function disableAiScoreButton() {
  console.log('Disabling AI score button');
  $('#ai-score-btn').prop('disabled', true);
}

// 验证评分方式显示一致性
window.validateGradeModeDisplay = function() {
  console.log('=== 验证评分方式显示一致性 ===');
  console.log('当前评分方式:', gradeMode);
  console.log('当前评分:', selectedGrade);

  // 检查评分方式按钮状态
  const letterButton = $('.grade-mode-btn[data-mode="letter"]');
  const textButton = $('.grade-mode-btn[data-mode="text"]');
  console.log('字母评分按钮active状态:', letterButton.hasClass('active'));
  console.log('文字评分按钮active状态:', textButton.hasClass('active'));

  // 检查评分按钮组显示状态
  const letterGroupVisible = $('#letter-grade-buttons').is(':visible');
  const textGroupVisible = $('#text-grade-buttons').is(':visible');
  console.log('字母评分按钮组显示状态:', letterGroupVisible);
  console.log('文字评分按钮组显示状态:', textGroupVisible);

  // 检查评分按钮状态
  const activeGradeButton = $('.grade-button.active');
  console.log('当前激活的评分按钮:', activeGradeButton.length, activeGradeButton.text());

  // 验证一致性
  let isConsistent = true;

  if (gradeMode === 'letter') {
    if (!letterButton.hasClass('active')) {
      console.error('字母评分方式但按钮未激活');
      isConsistent = false;
    }
    if (!letterGroupVisible) {
      console.error('字母评分方式但按钮组未显示');
      isConsistent = false;
    }
    if (textGroupVisible) {
      console.error('字母评分方式但文字按钮组仍显示');
      isConsistent = false;
    }
  } else if (gradeMode === 'text') {
    if (!textButton.hasClass('active')) {
      console.error('文字评分方式但按钮未激活');
      isConsistent = false;
    }
    if (!textGroupVisible) {
      console.error('文字评分方式但按钮组未显示');
      isConsistent = false;
    }
    if (letterGroupVisible) {
      console.error('文字评分方式但字母按钮组仍显示');
      isConsistent = false;
    }
  }

  console.log('评分方式显示一致性:', isConsistent);
  return isConsistent;
}

// 处理评分信息
window.handleGradeInfo = function(gradeInfo) {
    console.log('=== 处理评分信息开始 ===');
    console.log('评分信息:', gradeInfo);
    console.log('当前评分方式:', gradeMode);
    console.log('当前评分:', selectedGrade);

    if (gradeInfo.has_grade && gradeInfo.grade) {
        // 文件已有评分，设置按钮状态
        console.log('文件已有评分:', gradeInfo.grade, '类型:', gradeInfo.grade_type);

        // 更新全局变量
        selectedGrade = gradeInfo.grade;
        gradeMode = gradeInfo.grade_type || 'letter';

        // 根据评分类型切换评分方式
        if (gradeInfo.grade_type === 'letter') {
            switchGradeMode('letter');
        } else if (gradeInfo.grade_type === 'text') {
            switchGradeMode('text');
        }

        // 设置评分按钮状态
        setGradeButtonState(gradeInfo.grade);

        console.log('评分按钮状态已更新，当前评分:', selectedGrade, '评分方式:', gradeMode);
    } else {
        // 文件没有评分，保持用户当前的评分方式选择
        console.log('文件没有评分，保持当前评分方式:', gradeMode);

        // 保持当前的评分方式，不重置
        // 如果当前没有选择评分方式，才使用默认值
        if (!gradeMode) {
            console.log('没有评分方式，使用默认字母评分');
            gradeMode = 'letter';
            selectedGrade = 'B';
        } else {
            console.log('保持当前评分方式:', gradeMode);
            // 根据当前评分方式设置默认评分
            if (gradeMode === 'letter') {
                selectedGrade = selectedGrade || 'B';
                console.log('字母评分方式，默认评分:', selectedGrade);
            } else if (gradeMode === 'text') {
                selectedGrade = selectedGrade || '良好';
                console.log('文字评分方式，默认评分:', selectedGrade);
            }
        }

        // 应用当前的评分方式
        switchGradeMode(gradeMode);
        setGradeButtonState(selectedGrade);

        console.log('保持当前评分方式完成，当前评分:', selectedGrade, '评分方式:', gradeMode);
    }

    // 验证显示一致性
    validateGradeModeDisplay();
    console.log('=== 处理评分信息结束 ===');
}

// 处理文件内容显示
window.handleFileContent = function(response) {
    if (response.status === 'success') {
        const fileContent = $('#file-content');
        fileContent.empty();

        switch (response.type) {
            case 'text':
                // 文本文件
                fileContent.html(`<pre class="border p-3 bg-light">${response.content}</pre>`);
                break;
            case 'image':
                // 图片文件
                fileContent.html(`<img src="${response.content}" class="img-fluid" alt="图片">`);
                break;
            case 'pdf':
                // PDF 文件
                fileContent.html(`<iframe src="${response.content}" class="w-100" style="height: 800px;"></iframe>`);
                break;
            case 'excel':
                // Excel 文件
                try {
                    // 直接显示后端返回的 HTML 表格
                    fileContent.html(response.content);
                } catch (error) {
                    console.error('Error displaying Excel content:', error);
                    fileContent.html('<div class="alert alert-danger">无法显示 Excel 内容</div>');
                }
                break;
            case 'docx':
                // Word 文档
                try {
                    console.log('Displaying Word document content:', response.content);
                    fileContent.html(response.content);
                } catch (error) {
                    console.error('Error displaying Word content:', error);
                    fileContent.html('<div class="alert alert-danger">无法显示 Word 文档内容</div>');
                }
                break;
            case 'binary':
                // 二进制文件，提供下载链接
                fileContent.html(`
                    <div class="alert alert-info">
                        <i class="bi bi-download"></i>
                        <a href="${response.content}" class="alert-link" download>点击下载文件</a>
                    </div>
                `);
                break;
            default:
                fileContent.html('<div class="alert alert-warning">不支持的文件类型</div>');
        }

        // 处理评分信息
        console.log('=== 处理文件内容响应中的评分信息 ===');
        console.log('评分信息:', response.grade_info);
        console.log('当前评分方式:', gradeMode);
        console.log('当前评分:', selectedGrade);

        if (response.grade_info) {
            handleGradeInfo(response.grade_info);
        } else {
            console.log('响应中没有评分信息，保持当前评分方式');
            // 如果没有评分信息，保持当前的评分方式选择
            if (!gradeMode) {
                console.log('没有评分方式，使用默认字母评分');
                gradeMode = 'letter';
                selectedGrade = 'B';
            } else {
                console.log('保持当前评分方式:', gradeMode);
                // 根据当前评分方式设置默认评分
                if (gradeMode === 'letter') {
                    selectedGrade = selectedGrade || 'B';
                    console.log('字母评分方式，默认评分:', selectedGrade);
                } else if (gradeMode === 'text') {
                    selectedGrade = selectedGrade || '良好';
                    console.log('文字评分方式，默认评分:', selectedGrade);
                }
            }

            // 应用当前的评分方式
            switchGradeMode(gradeMode);
            setGradeButtonState(selectedGrade);
            console.log('保持当前评分方式完成，当前评分:', selectedGrade, '评分方式:', gradeMode);
        }
        console.log('=== 处理文件内容响应中的评分信息结束 ===');
    } else {
        $('#file-content').html(`<div class="alert alert-danger">${response.message}</div>`);
    }
}

// 加载文件内容
window.loadFile = function(path) {
    console.log('Loading file:', path);
    showLoading();
    currentFilePath = path;

    // 禁用教师评价按钮，直到文件加载完成
    disableTeacherCommentButton();

    // 禁用AI评分按钮，直到文件加载完成
    disableAiScoreButton();

    // 禁用确定按钮，直到文件加载完成
    $('#add-grade-to-file').prop('disabled', true);

    // 获取当前文件所在目录
    const dirPath = path.substring(0, path.lastIndexOf('/'));
    if (!dirPath) {
        console.error('Invalid directory path');
        $('#directory-file-count').text('0');
        return;
    }

    console.log('Current directory path:', dirPath);
    console.log('Current file path:', currentFilePath);

    // 尝试从目录树中获取缓存的文件数量
    const tree = $('#directory-tree').jstree(true);
    const node = tree.get_node(dirPath);
    console.log('Directory node:', node);

    if (node && node.data && node.data.file_count !== undefined) {
        console.log('Using cached file count:', node.data.file_count);
        $('#directory-file-count').text(node.data.file_count);
    } else {
        // 如果没有缓存，则从服务器获取
        console.log('No cached file count, fetching from server');

        // 准备请求数据
        const requestData = {
            path: dirPath
        };
        console.log('Request data:', requestData);

        // 获取CSRF Token
        const csrfToken = getCSRFToken();
        console.log('CSRF Token:', csrfToken);

        $.ajax({
            url: '/grading/get_dir_file_count/',
            method: 'POST',
            headers: {
                'X-CSRFToken': csrfToken,
                'Content-Type': 'application/json; charset=utf-8'
            },
            data: JSON.stringify(requestData),
            processData: false,
            contentType: 'application/json; charset=utf-8',
            success: function(response) {
                console.log('Response:', response);
                console.log('Response type:', typeof response);
                console.log('Response text:', response);

                // 直接使用响应文本作为文件数量
                const fileCount = response;
                console.log('Setting file count to:', fileCount);
                $('#directory-file-count').text(fileCount);
                console.log(`Found ${fileCount} files in directory: ${dirPath}`);

                // 更新目录树中的缓存
                if (node) {
                    node.data = node.data || {};
                    node.data.file_count = fileCount;
                    tree.redraw_node(node);
                }
            },
            error: function(xhr, status, error) {
                console.error('Error getting file count:', error);
                console.error('XHR status:', xhr.status);
                console.error('XHR response:', xhr.responseText);
                console.error('XHR status text:', xhr.statusText);
                console.error('XHR ready state:', xhr.readyState);
                $('#directory-file-count').text('0');
                showError('获取文件数量失败');
            }
        });
    }

    // 添加超时处理
    const timeout = setTimeout(() => {
        hideLoading();
        showError('加载文件超时，请重试');
    }, 30000); // 30秒超时

    $.ajax({
        url: '/grading/get_file_content/',
        method: 'POST',
        headers: {
            'X-CSRFToken': getCSRFToken()
        },
        data: {
            path: path
        },
        success: function(response) {
            clearTimeout(timeout);
            console.log('File content response:', response);
            handleFileContent(response);

            // 启用教师评价按钮
            enableTeacherCommentButton();

            // 启用AI评分按钮
            enableAiScoreButton();

            // 启用确定按钮
            $('#add-grade-to-file').prop('disabled', false);
        },
        error: function(xhr, status, error) {
            clearTimeout(timeout);
            console.error('Error loading file:', error);
            console.error('XHR status:', xhr.status);
            console.error('XHR response:', xhr.responseText);
            showError('加载文件失败：' + (error || '未知错误'));

            // 禁用教师评价按钮
            disableTeacherCommentButton();

            // 禁用AI评分按钮
            disableAiScoreButton();

            // 禁用确定按钮
            $('#add-grade-to-file').prop('disabled', true);
        },
        complete: function() {
            clearTimeout(timeout);
            hideLoading();
        }
    });
}

// 保存评分
window.saveGrade = function(grade) {
    console.log('Saving grade:', grade);
    if (!currentFilePath) {
        showError('请先选择要评分的文件');
        return;
    }

    // 更新按钮状态
    setGradeButtonState(grade);
    // 保存当前选中的评分
    selectedGrade = grade;
    // 直接调用 addGradeToFile 进行评分并切换下一个文件
    addGradeToFile(grade);
}

// 获取所有文件节点
window.getAllFileNodes = function() {
    const tree = $('#directory-tree').jstree(true);
    const allNodes = tree.get_json('#', { flat: true });
    return allNodes.filter(node => node.type === 'file');
}

// 获取当前文件在文件列表中的索引
window.getCurrentFileIndex = function() {
    const fileNodes = getAllFileNodes();
    const currentFile = $('#directory-tree').jstree('get_selected', true)[0];
    if (!currentFile) return -1;
    return fileNodes.findIndex(node => node.id === currentFile.id);
}

// 导航到上一个文件
window.navigateToPrevFile = function() {
    const fileNodes = getAllFileNodes();
    const currentIndex = getCurrentFileIndex();

    if (currentIndex > 0) {
        const prevNode = fileNodes[currentIndex - 1];
        $('#directory-tree').jstree('select_node', prevNode.id);
    }
}

// 导航到下一个文件
window.navigateToNextFile = function() {
    const fileNodes = getAllFileNodes();
    const currentIndex = getCurrentFileIndex();

    if (currentIndex < fileNodes.length - 1) {
        const nextNode = fileNodes[currentIndex + 1];
        $('#directory-tree').jstree('select_node', nextNode.id);
    }
}

// 更新导航按钮状态
window.updateNavigationButtons = function() {
    const fileNodes = getAllFileNodes();
    const currentIndex = getCurrentFileIndex();

    $('#prev-file').prop('disabled', currentIndex <= 0);
    $('#next-file').prop('disabled', currentIndex >= fileNodes.length - 1);
}

// 在文件选择时更新导航按钮状态
$('#directory-tree').on('select_node.jstree', function(e, data) {
    if (data.node.type === 'file') {
        updateNavigationButtons();
    }
});

// 修改addGradeToFile函数，在评分后自动导航到下一个文件
window.addGradeToFile = function(grade) {
    console.log('Adding grade to file:', grade);
    console.log('Current file path:', currentFilePath);

    if (!currentFilePath) {
        showError('请先选择要评分的文件');
        return;
    }

    if (!grade) {
        showError('请先选择一个评分');
        return;
    }

    showLoading();
    $.ajax({
        url: '/grading/add_grade_to_file/',
        method: 'POST',
        headers: {
            'X-CSRFToken': getCSRFToken()
        },
        data: {
            path: currentFilePath,
            grade: grade
        },
        success: function(response) {
            console.log('Grade added successfully:', response);
            if (response.status === 'success') {
                const alertHtml = `
                    <div class="alert alert-success alert-dismissible fade show" role="alert">
                        评分已添加到文件末尾
                        <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
                    </div>
                `;
                $('#file-content').prepend(alertHtml);

                // 获取所有文件节点
                const fileNodes = getAllFileNodes();
                const currentIndex = getCurrentFileIndex();
                console.log('Current file index:', currentIndex);
                console.log('Total files:', fileNodes.length);

                // 自动导航到下一个文件
                if (currentIndex < fileNodes.length - 1) {
                    const nextNode = fileNodes[currentIndex + 1];
                    console.log('Navigating to next file:', nextNode.id);
                    // 使用 jstree 的 select_node 方法选中下一个文件
                    $('#directory-tree').jstree('select_node', nextNode.id);
                    // 加载下一个文件的内容
                    loadFile(nextNode.id);
                } else {
                    console.log('Last file reached, reloading current file');
                    // 如果是最后一个文件，重新加载当前文件以显示新添加的评分
                    loadFile(currentFilePath);
                }
            } else {
                showError(response.message);
            }
        },
        error: function(xhr, status, error) {
            console.error('Error adding grade to file:', error);
            showError('添加评分到文件失败：' + error);
        },
        complete: function() {
            hideLoading();
        }
    });
}

// 撤销评分
window.cancelGrade = function() {
    if (!currentFilePath) {
        showError('请先选择要评分的文件');
        return;
    }

    showLoading();
    $.ajax({
        url: '/grading/remove_grade/',
        method: 'POST',
        headers: {
            'X-CSRFToken': getCSRFToken()
        },
        data: {
            path: currentFilePath
        },
        success: function(response) {
            if (response.status === 'success') {
                // 恢复之前的评分状态
                setGradeButtonState(selectedGrade);
                pendingGrade = null;
                // 禁用确定按钮
                $('#add-grade-to-file').prop('disabled', true);

                // 重新加载文件内容
                loadFile(currentFilePath);

                const alertHtml = `
                    <div class="alert alert-success alert-dismissible fade show" role="alert">
                        评分已撤销
                        <button type="button" class="btn-close" data-bs-dismiss="alert" aria-label="Close"></button>
                    </div>
                `;
                $('#file-content').prepend(alertHtml);
            } else {
                showError(response.message);
            }
        },
        error: function(xhr, status, error) {
            console.error('Error removing grade:', error);
            showError('撤销评分失败：' + error);
        },
        complete: function() {
            hideLoading();
        }
    });
}

// 初始化文件树
window.initTree = function() {
    console.log('Initializing tree...');
    console.log('Initial tree data:', window.initialTreeData);

    // 确保 initialTreeData 是数组
    const initialData = Array.isArray(window.initialTreeData) ? window.initialTreeData : [];
    console.log('Processed initial data:', initialData);

    // 销毁现有的树（如果存在）
    if ($('#directory-tree').jstree(true)) {
        $('#directory-tree').jstree(true).destroy();
    }

    // 显示加载状态
    $('#directory-tree').html('<div class="text-center"><div class="spinner-border text-primary" role="status"><span class="visually-hidden">加载中...</span></div></div>');

    // 配置 jstree
    const treeConfig = {
        'core': {
            'data': initialData,
            'check_callback': true,
            'multiple': false,  // 确保只能选择一个节点
            'themes': {
                'responsive': true,
                'dots': true,
                'icons': true,
                'stripes': true,
                'variant': 'large',
                'url': '/static/grading/vendor/jstree/themes/default/style.min.css',
                'dir': '/static/grading/vendor/jstree/themes/default/'
            }
        },
        'types': {
            'default': {
                'icon': 'jstree-file'
            },
            'file': {
                'icon': 'jstree-file'
            },
            'folder': {
                'icon': 'jstree-folder'
            }
        },
        'plugins': ['types', 'wholerow', 'state', 'contextmenu'],
        'contextmenu': {
            'items': function(node) {
                var items = {};
                if (node.type === 'folder') {
                    items.batchAiScore = {
                        "label": "<i class='bi bi-robot'></i> 批量AI评分",
                        "action": function(obj) {
                            handleBatchAiScore(node.id);
                        }
                    };
                }
                return items;
            }
        },
        'state': {
            'key': 'grading-tree',
            'filter': function(state) {
                // 只保存打开/关闭状态
                return {
                    'core': {
                        'open': state.core.open,
                        'selected': state.core.selected
                    }
                };
            }
        }
    };

    // 初始化 jstree
    $('#directory-tree').jstree(treeConfig).on('ready.jstree', function() {
        console.log('Tree initialized');
        // 树初始化完成后，如果有初始选中的节点，加载其内容
        const selectedNodes = $('#directory-tree').jstree('get_selected');
        if (selectedNodes.length > 0) {
            const node = $('#directory-tree').jstree('get_node', selectedNodes[0]);
            if (node && node.type === 'file') {
                loadFile(node.id);
            }
        }
    }).on('select_node.jstree', function(e, data) {
        // 确保只处理文件节点
        if (data.node.type === 'file') {
            // 取消其他节点的选中状态
            const selectedNodes = $('#directory-tree').jstree('get_selected');
            selectedNodes.forEach(nodeId => {
                if (nodeId !== data.node.id) {
                    $('#directory-tree').jstree('deselect_node', nodeId);
                }
            });

            // 加载文件内容
            loadFile(data.node.id);
            // 更新导航按钮状态
            updateNavigationButtons();
        }
    });
}

// 新增：处理批量AI评分
function handleBatchAiScore(path) {
    if (!confirm(`确定要对目录 "${path}" 下的所有作业进行批量AI评分吗？\n这个过程可能需要一些时间。`)) {
        return;
    }

    console.log('开始批量AI评分，目录路径:', path);
    showLoading();

    $.ajax({
        url: '/grading/batch_ai_score/',
        method: 'POST',
        headers: {
            'X-CSRFToken': getCSRFToken()
        },
        data: {
            path: path
        },
        success: function(response) {
            if (response.status === 'success') {
                // 构建结果显示的HTML
                let resultsHtml = '<ul class="list-group">';
                response.results.forEach(function(result) {
                    if (result.success) {
                        resultsHtml += `<li class="list-group-item list-group-item-success">${result.file}: 成功 (分数: ${result.score}, 等级: ${result.grade})</li>`;
                    } else {
                        resultsHtml += `<li class="list-group-item list-group-item-danger">${result.file}: 失败 (${result.error})</li>`;
                    }
                });
                resultsHtml += '</ul>';

                // 使用一个模态框来显示详细结果
                $('#batch-score-results-body').html(resultsHtml);
                $('#batch-score-summary').text(response.message);
                $('#batchScoreResultModal').modal('show');

                // 刷新文件树以更新状态
                $('#directory-tree').jstree(true).refresh();

            } else {
                showError('批量AI评分失败: ' + response.message);
            }
        },
        error: function(xhr, status, error) {
            console.error('批量AI评分请求失败:', error);
            let errorMessage = '批量AI评分请求失败';
            if (xhr.responseJSON && xhr.responseJSON.message) {
                errorMessage = xhr.responseJSON.message;
            } else if (xhr.status === 400) {
                errorMessage = '请求参数错误';
            } else if (xhr.status === 500) {
                errorMessage = '服务器内部错误';
            }
            showError(errorMessage);
        },
        complete: function() {
            hideLoading();
        }
    });
}

// 显示AI评分提示模态框
function showAiScoreAlertModal(message, filePath) {
    console.log('显示AI评分提示模态框:', message, filePath);

    // 设置提示信息
    $('#aiScoreAlertMessage').text(message);

    // 加载文件内容
    loadFileContentForModal(filePath);

    // 加载评分信息
    loadGradeInfoForModal(filePath);

    // 显示模态框
    $('#aiScoreAlertModal').modal('show');
}

// 为模态框加载文件内容
function loadFileContentForModal(filePath) {
    if (!filePath) {
        $('#fileContentPreview').html('<div class="text-danger">文件路径无效</div>');
        return;
    }

    $('#fileContentPreview').html('<div class="text-muted">正在加载文件内容...</div>');

    $.ajax({
        url: '/grading/get_file_content/',
        method: 'GET',
        data: {
            file_path: filePath
        },
        success: function(response) {
            if (response.success) {
                let content = response.content || '文件内容为空';
                // 限制显示长度，避免模态框过大
                if (content.length > 2000) {
                    content = content.substring(0, 2000) + '\n\n... (内容过长，已截断)';
                }
                $('#fileContentPreview').html('<pre style="white-space: pre-wrap; word-wrap: break-word;">' +
                    content.replace(/</g, '&lt;').replace(/>/g, '&gt;') + '</pre>');
            } else {
                $('#fileContentPreview').html('<div class="text-danger">加载文件内容失败: ' + (response.message || '未知错误') + '</div>');
            }
        },
        error: function(xhr, status, error) {
            console.error('加载文件内容失败:', error);
            $('#fileContentPreview').html('<div class="text-danger">加载文件内容失败: ' + error + '</div>');
        }
    });
}

// 为模态框加载评分信息
function loadGradeInfoForModal(filePath) {
    if (!filePath) {
        $('#gradeInfoPreview').html('<div class="text-danger">文件路径无效</div>');
        return;
    }

    $('#gradeInfoPreview').html('<div class="text-muted">正在检查评分信息...</div>');

    // 使用专门的API来获取评分信息
    $.ajax({
        url: '/grading/get_file_grade_info/',
        method: 'GET',
        data: {
            file_path: filePath
        },
        success: function(response) {
            if (response.status === 'success') {
                let gradeInfo = formatGradeInfoForModal(response.grade_info, response.content_preview, response.content_length);
                $('#gradeInfoPreview').html(gradeInfo);
            } else {
                $('#gradeInfoPreview').html('<div class="text-danger">检查评分信息失败: ' + (response.message || '未知错误') + '</div>');
            }
        },
        error: function(xhr, status, error) {
            console.error('检查评分信息失败:', error);
            $('#gradeInfoPreview').html('<div class="text-danger">检查评分信息失败: ' + error + '</div>');
        }
    });
}

// 格式化评分信息用于模态框显示
function formatGradeInfoForModal(gradeInfo, contentPreview, contentLength) {
    let html = '<div class="mb-2"><strong>评分信息分析：</strong></div>';

    // 显示评分状态
    if (gradeInfo.has_grade) {
        html += '<div class="alert alert-warning mb-2">';
        html += '<i class="bi bi-exclamation-triangle"></i> <strong>已发现评分！</strong>';
        html += '</div>';

        // 显示具体评分信息
        html += '<div class="card mb-2">';
        html += '<div class="card-body p-2">';
        html += '<div class="row">';
        html += '<div class="col-6"><strong>评分：</strong></div>';
        html += '<div class="col-6"><span class="badge bg-primary">' + gradeInfo.grade + '</span></div>';
        html += '</div>';
        html += '<div class="row">';
        html += '<div class="col-6"><strong>评分类型：</strong></div>';
        html += '<div class="col-6"><span class="badge bg-info">' + (gradeInfo.grade_type || '未知') + '</span></div>';
        html += '</div>';
        html += '<div class="row">';
        html += '<div class="col-6"><strong>位置：</strong></div>';
        html += '<div class="col-6"><span class="badge bg-secondary">' + (gradeInfo.in_table ? '表格中' : '段落中') + '</span></div>';
        html += '</div>';
        html += '</div>';
        html += '</div>';

        // 显示AI评分状态
        html += '<div class="alert alert-danger mb-2">';
        html += '<i class="bi bi-robot"></i> <strong>AI评分已禁用</strong><br>';
        html += '该文件已有评分，无法进行AI评分。如需重新评分，请先删除现有评分。';
        html += '</div>';
    } else {
        html += '<div class="alert alert-success mb-2">';
        html += '<i class="bi bi-check-circle"></i> <strong>未发现评分</strong><br>';
        html += '该文件可以进行AI评分。';
        html += '</div>';
    }

    // 显示文件基本信息
    html += '<hr><div class="small text-muted">';
    html += '<div><strong>文件大小：</strong>' + (contentLength || 0) + ' 字符</div>';
    html += '<div><strong>内容预览：</strong></div>';
    html += '<div style="max-height: 100px; overflow-y: auto; font-size: 0.8em; background-color: #fff; padding: 5px; border: 1px solid #dee2e6;">';
    html += contentPreview.replace(/</g, '&lt;').replace(/>/g, '&gt;');
    html += '</div></div>';

    return html;
}

// 页面加载完成后初始化树
$(document).ready(function() {
    console.log('=== 页面加载开始 ===');
    console.log('Document ready, initializing tree...');

    // 基本检查
    console.log('jQuery版本:', $.fn.jquery);
    console.log('页面标题:', document.title);

    // 检查教师评价按钮的初始状态
    console.log('Initial teacher comment button disabled state:', $('#teacher-comment-btn').prop('disabled'));
    console.log('Teacher comment button element:', $('#teacher-comment-btn').length);

    // 确保教师评价按钮初始状态为禁用
    disableTeacherCommentButton();

    // 确保AI评分按钮初始状态为禁用
    disableAiScoreButton();

    // 设置初始树数据
    if (window.initialTreeData) {
        console.log('Initial tree data:', window.initialTreeData);
        initTree();
    } else {
        console.error('No initial tree data available');
    }

    // 设置默认评分按钮状态（仅在页面初始化时）
    console.log('=== 页面初始化评分状态 ===');
    console.log('初始化前字母评分按钮组显示状态:', $('#letter-grade-buttons').is(':visible'));
    console.log('初始化前文字评分按钮组显示状态:', $('#text-grade-buttons').is(':visible'));

    // 初始化默认状态（如果还没有设置的话）
    if (!gradeMode) {
        console.log('初始化默认评分方式: letter');
        gradeMode = 'letter';
        selectedGrade = 'B';
    } else {
        console.log('保持现有评分方式:', gradeMode, '评分:', selectedGrade);
    }

    // 设置默认评分方式
    switchGradeMode(gradeMode);

    console.log('初始化后字母评分按钮组显示状态:', $('#letter-grade-buttons').is(':visible'));
    console.log('初始化后文字评分按钮组显示状态:', $('#text-grade-buttons').is(':visible'));

    // 评分模式按钮事件绑定（防止HTML onclick未定义问题）
    $(document).off('click', '.grade-mode-btn').on('click', '.grade-mode-btn', function(e) {
        e.preventDefault();
        e.stopPropagation();
        var mode = $(this).data('mode');
        if (typeof window.switchGradeMode === 'function') {
            window.switchGradeMode(mode);
        } else {
            console.error('window.switchGradeMode 未定义');
        }
    });

    // 检查按钮是否存在
    console.log('=== 评分方式按钮检查 ===');
    console.log('评分方式按钮总数:', $('.grade-mode-btn').length);
    $('.grade-mode-btn').each(function(index) {
        console.log(`按钮 ${index}:`, $(this).text(), 'data-mode:', $(this).data('mode'));
    });

    // 检查所有相关元素
    console.log('=== DOM元素检查 ===');
    console.log('字母评分按钮组元素:', $('#letter-grade-buttons')[0]);
    console.log('文字评分按钮组元素:', $('#text-grade-buttons')[0]);
    console.log('字母评分按钮组HTML:', $('#letter-grade-buttons').html());
    console.log('文字评分按钮组HTML:', $('#text-grade-buttons').html());
    console.log('字母评分按钮组CSS display:', $('#letter-grade-buttons').css('display'));
    console.log('文字评分按钮组CSS display:', $('#text-grade-buttons').css('display'));

    // 检查评分方式切换功能是否正常
    console.log('=== 评分方式切换功能检查 ===');
    console.log('字母等级按钮:', $('.grade-mode-btn[data-mode="letter"]').length);
    console.log('文字等级按钮:', $('.grade-mode-btn[data-mode="text"]').length);
    console.log('字母评分按钮组:', $('#letter-grade-buttons').length);
    console.log('文字评分按钮组:', $('#text-grade-buttons').length);

    // 检查按钮组的显示状态
    console.log('字母评分按钮组显示状态:', $('#letter-grade-buttons').is(':visible'));
    console.log('文字评分按钮组显示状态:', $('#text-grade-buttons').is(':visible'));

    // 绑定评分按钮点击事件
    $(document).on('click', '.grade-button', function() {
        const grade = $(this).data('grade');
        console.log('Grade button clicked:', grade);
        saveGrade(grade);
    });

    // 绑定确定按钮点击事件
    $(document).on('click', '#add-grade-to-file', function() {
        console.log('Confirm button clicked, using selected grade:', selectedGrade);
        // 使用当前选中的评分
        addGradeToFile(selectedGrade);
    });

    // 绑定撤销按钮点击事件
    $(document).on('click', '#cancel-grade', function() {
        cancelGrade();
    });

    // 绑定导航按钮事件
    $(document).on('click', '#prev-file', function() {
        navigateToPrevFile();
    });

    $(document).on('click', '#next-file', function() {
        navigateToNextFile();
    });

    // 绑定教师评价按钮点击事件
    $(document).on('click', '#teacher-comment-btn', function() {
        console.log('教师评价按钮被点击，当前文件路径:', currentFilePath);
        if (currentFilePath) {
            // 直接显示模态框，评价内容会在模态框显示时自动加载
            $('#teacherCommentModal').modal('show');
        } else {
            alert('请先选择文件');
        }
    });

    // 绑定保存教师评价按钮点击事件
    $(document).on('click', '#saveTeacherComment', function() {
        console.log('保存教师评价按钮被点击');
        saveTeacherComment();
    });

    // 新增：绑定AI评分按钮点击事件
    $(document).on('click', '#ai-score-btn', function() {
        console.log('=== AI评分按钮被点击 ===');
        console.log('当前文件路径:', currentFilePath);
        console.log('按钮状态:', $(this).prop('disabled'));
        console.log('按钮文本:', $(this).text());

        if (!currentFilePath) {
            alert('请先选择一个文件进行AI评分');
            return;
        }

        console.log('AI评分按钮被点击，文件路径:', currentFilePath);
        showLoading();

        // 禁用按钮防止重复点击
        $(this).prop('disabled', true).html('<span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span> 评分中...');

        $.ajax({
            url: '/grading/ai_score/',
            method: 'POST',
            headers: {
                'X-CSRFToken': getCSRFToken()
            },
            data: {
                path: currentFilePath
            },
            success: function(response) {
                if (response.status === 'success') {
                    // 使用一个模态框或者alert来显示结果
                    alert(`AI评分完成！\n\n分数: ${response.score}\n等级: ${response.grade}\n\n评语:\n${response.comment}`);
                    // 刷新文件内容以显示新的评分和评语
                    loadFile(currentFilePath);
                } else {
                    showError('AI评分失败: ' + response.message);
                }
            },
            error: function(xhr, status, error) {
                console.error('AI评分请求失败:', error);
                let errorMessage = 'AI评分请求失败';
                if (xhr.responseJSON && xhr.responseJSON.message) {
                    errorMessage = xhr.responseJSON.message;
                    // 如果是已有评分的错误，显示弹出框
                    if (xhr.status === 400 && errorMessage.includes('已有评分')) {
                        showAiScoreAlertModal(errorMessage, currentFilePath);
                        return;
                    }
                } else if (xhr.status === 400) {
                    errorMessage = '请求参数错误';
                } else if (xhr.status === 500) {
                    errorMessage = '服务器内部错误';
                }
                showError(errorMessage);
            },
            complete: function() {
                // 恢复按钮状态
                $('#ai-score-btn').prop('disabled', false).html('<i class="bi bi-robot"></i> AI评分');
                hideLoading();
            }
        });
    });

    // 模态框显示时自动加载评价内容
    $('#teacherCommentModal').on('show.bs.modal', function() {
        console.log('=== 教师评价模态框显示 ===');
        console.log('当前文件路径:', currentFilePath);
        console.log('输入框元素:', $('#teacherCommentText').length);

        if (currentFilePath) {
            console.log('开始加载评价内容...');
            // 自动加载当前文件的评价内容到输入框
            loadTeacherComment(currentFilePath);
        } else {
            console.log('没有当前文件路径，清空输入框');
            $('#teacherCommentText').val('');
        }
    });

    // AI评分提示模态框事件处理
    $('#aiScoreAlertModal').on('show.bs.modal', function() {
        // 隐藏强制AI评分按钮（默认情况下）
        $('#forceAiScore').hide();
    });

    // 强制AI评分按钮点击事件
    $('#forceAiScore').on('click', function() {
        if (currentFilePath) {
            // 关闭模态框
            $('#aiScoreAlertModal').modal('hide');

            // 执行强制AI评分（这里可以添加一个特殊的参数来跳过检查）
            console.log('执行强制AI评分:', currentFilePath);
            // TODO: 实现强制AI评分功能
            alert('强制AI评分功能正在开发中...');
        }
    });
});

// 教师评价相关函数
window.loadTeacherComment = function(filePath) {
    console.log('加载教师评价，文件路径:', filePath);
    if (!filePath) {
        $('#teacherCommentText').val('');
        return;
    }

    $.ajax({
        url: '/grading/get_teacher_comment/',
        method: 'GET',
        data: {
            file_path: filePath
        },
        success: function(response) {
            console.log('=== 获取教师评价响应 ===');
            console.log('响应内容:', response);
            console.log('响应类型:', typeof response);
            console.log('响应success字段:', response.success);
            console.log('响应comment字段:', response.comment);

            if (response.success) {
                console.log('获取评价成功，准备更新显示');
                const commentText = response.comment || '';
                console.log('评价文本:', commentText);
                console.log('输入框元素存在:', $('#teacherCommentText').length > 0);

                // 将评价内容载入到输入框中，方便直接修改
                $('#teacherCommentText').val(commentText);

                console.log('评价内容已载入到输入框');
                console.log('输入框当前值:', $('#teacherCommentText').val());

                // 如果评价内容为空或"暂无评价"，显示提示信息
                if (!commentText || commentText === '暂无评价') {
                    console.log('文件中没有找到评价内容，显示提示信息');
                    $('#teacherCommentText').attr('placeholder', '文件中没有找到评价内容，请在此输入新的评价...');
                }
            } else {
                console.error('获取评价失败:', response.message);
                alert('获取评价失败: ' + response.message);
            }
        },
        error: function(xhr, status, error) {
            console.error('获取教师评价失败:', error);
            console.error('XHR状态:', xhr.status);
            console.error('XHR响应:', xhr.responseText);
            alert('获取评价失败: ' + error);
        }
    });
}

window.saveTeacherComment = function() {
    const comment = $('#teacherCommentText').val().trim();
    console.log('保存教师评价，内容:', comment);

    if (!comment) {
        alert('请输入评价内容');
        return;
    }

    if (!currentFilePath) {
        alert('请先选择文件');
        return;
    }

    $.ajax({
        url: '/grading/save_teacher_comment/',
        method: 'POST',
        headers: {
            'X-CSRFToken': getCSRFToken()
        },
        data: {
            file_path: currentFilePath,
            comment: comment
        },
        success: function(response) {
            console.log('=== 保存教师评价响应 ===');
            console.log('响应内容:', response);
            console.log('响应类型:', typeof response);
            console.log('响应success字段:', response.success);

            if (response.success) {
                console.log('保存成功，准备刷新评价显示');

                // 延迟一点时间再加载评价，确保文件写入完成
                setTimeout(function() {
                    console.log('开始重新加载教师评价');
                    loadTeacherComment(currentFilePath);

                    // 重新加载文件内容，确保评分方式显示正确
                    console.log('重新加载文件内容以更新评分方式显示');
                    loadFile(currentFilePath);
                }, 500);

                $('#teacherCommentModal').modal('hide');
            } else {
                console.error('保存失败:', response.message);
                alert('保存失败: ' + response.message);
            }
        },
        error: function(xhr, status, error) {
            console.error('保存教师评价失败:', error);
            console.error('XHR状态:', xhr.status);
            console.error('XHR响应:', xhr.responseText);
            alert('保存失败，请重试');
        }
    });
}
